
Research
/Security News
Toptal’s GitHub Organization Hijacked: 10 Malicious Packages Published
Threat actors hijacked Toptal’s GitHub org, publishing npm packages with malicious payloads that steal tokens and attempt to wipe victim systems.
Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input
Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input
Memory is automatically released when an item expires or the cache is cleared.
By default, only the memoized function's first argument is considered via strict equality comparison. If you need to cache multiple arguments or cache object
s by value, have a look at alternative caching strategies below.
If you want to memoize Promise-returning functions (like async
functions), you might be better served by p-memoize.
npm install memoize
import memoize from 'memoize';
let index = 0;
const counter = () => ++index;
const memoized = memoize(counter);
memoized('foo');
//=> 1
// Cached as it's the same argument
memoized('foo');
//=> 1
// Not cached anymore as the argument changed
memoized('bar');
//=> 2
memoized('bar');
//=> 2
// Only the first argument is considered by default
memoized('bar', 'foo');
//=> 2
But you might want to use p-memoize for more Promise-specific behaviors.
import memoize from 'memoize';
let index = 0;
const counter = async () => ++index;
const memoized = memoize(counter);
console.log(await memoized());
//=> 1
// The return value didn't increase as it's cached
console.log(await memoized());
//=> 1
import memoize from 'memoize';
import got from 'got';
import delay from 'delay';
const memoizedGot = memoize(got, {maxAge: 1000});
await memoizedGot('https://sindresorhus.com');
// This call is cached
await memoizedGot('https://sindresorhus.com');
await delay(2000);
// This call is not cached as the cache has expired
await memoizedGot('https://sindresorhus.com');
By default, only the first argument is compared via exact equality (===
) to determine whether a call is identical.
import memoize from 'memoize';
const pow = memoize((a, b) => Math.pow(a, b));
pow(2, 2); // => 4, stored in cache with the key 2 (number)
pow(2, 3); // => 4, retrieved from cache at key 2 (number), it's wrong
You will have to use the cache
and cacheKey
options appropriate to your function. In this specific case, the following could work:
import memoize from 'memoize';
const pow = memoize((a, b) => Math.pow(a, b), {
cacheKey: arguments_ => arguments_.join(',')
});
pow(2, 2); // => 4, stored in cache with the key '2,2' (both arguments as one string)
pow(2, 3); // => 8, stored in cache with the key '2,3'
More advanced examples follow.
If your function accepts an object, it won't be memoized out of the box:
import memoize from 'memoize';
const heavyMemoizedOperation = memoize(heavyOperation);
heavyMemoizedOperation({full: true}); // Stored in cache with the object as key
heavyMemoizedOperation({full: true}); // Stored in cache with the object as key, again
// The objects appear the same, but in JavaScript, they're different objects
You might want to serialize or hash them, for example using JSON.stringify
or something like serialize-javascript, which can also serialize RegExp
, Date
and so on.
import memoize from 'memoize';
const heavyMemoizedOperation = memoize(heavyOperation, {cacheKey: JSON.stringify});
heavyMemoizedOperation({full: true}); // Stored in cache with the key '[{"full":true}]' (string)
heavyMemoizedOperation({full: true}); // Retrieved from cache
The same solution also works if it accepts multiple serializable objects:
import memoize from 'memoize';
const heavyMemoizedOperation = memoize(heavyOperation, {cacheKey: JSON.stringify});
heavyMemoizedOperation('hello', {full: true}); // Stored in cache with the key '["hello",{"full":true}]' (string)
heavyMemoizedOperation('hello', {full: true}); // Retrieved from cache
If your function accepts multiple arguments that aren't supported by JSON.stringify
(e.g. DOM elements and functions), you can instead extend the initial exact equality (===
) to work on multiple arguments using many-keys-map
:
import memoize from 'memoize';
import ManyKeysMap from 'many-keys-map';
const addListener = (emitter, eventName, listener) => emitter.on(eventName, listener);
const addOneListener = memoize(addListener, {
cacheKey: arguments_ => arguments_, // Use *all* the arguments as key
cache: new ManyKeysMap() // Correctly handles all the arguments for exact equality
});
addOneListener(header, 'click', console.log); // `addListener` is run, and it's cached with the `arguments` array as key
addOneListener(header, 'click', console.log); // `addListener` is not run again because the arguments are the same
addOneListener(mainContent, 'load', console.log); // `addListener` is run, and it's cached with the `arguments` array as key
Better yet, if your function’s arguments are compatible with WeakMap
, you should use deep-weak-map
instead of many-keys-map
. This will help avoid memory leaks.
Type: Function
The function to be memoized.
Type: object
Type: number
| Function
Default: Infinity
Example: arguments_ => arguments_ < new Date() ? Infinity : 60_000
Milliseconds until the cache entry expires.
If a function is provided, it receives the arguments and must return the max age.
Type: Function
Default: arguments_ => arguments_[0]
Example: arguments_ => JSON.stringify(arguments_)
Determines the cache key for storing the result based on the function arguments. By default, only the first argument is considered.
A cacheKey
function can return any type supported by Map
(or whatever structure you use in the cache
option).
Refer to the caching strategies section for more information.
Type: object
Default: new Map()
Use a different cache storage. Must implement the following methods: .has(key)
, .get(key)
, .set(key, value)
, .delete(key)
, and optionally .clear()
. You could for example use a WeakMap
instead or quick-lru
for a LRU cache.
Refer to the caching strategies section for more information.
Returns a decorator to memoize class methods or static class methods.
Notes:
--experimentalDecorators
; follow TypeScript’s docs.Type: object
Same as options for memoize()
.
import {memoizeDecorator} from 'memoize';
class Example {
index = 0
@memoizeDecorator()
counter() {
return ++this.index;
}
}
class ExampleWithOptions {
index = 0
@memoizeDecorator({maxAge: 1000})
counter() {
return ++this.index;
}
}
Clear all cached data of a memoized function.
Type: Function
The memoized function.
If you want to know how many times your cache had a hit or a miss, you can make use of stats-map as a replacement for the default cache.
import memoize from 'memoize';
import StatsMap from 'stats-map';
import got from 'got';
const cache = new StatsMap();
const memoizedGot = memoize(got, {cache});
await memoizedGot('https://sindresorhus.com');
await memoizedGot('https://sindresorhus.com');
await memoizedGot('https://sindresorhus.com');
console.log(cache.stats);
//=> {hits: 2, misses: 1}
FAQs
Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input
The npm package memoize receives a total of 698,995 weekly downloads. As such, memoize popularity was classified as popular.
We found that memoize demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
/Security News
Threat actors hijacked Toptal’s GitHub org, publishing npm packages with malicious payloads that steal tokens and attempt to wipe victim systems.
Research
/Security News
Socket researchers investigate 4 malicious npm and PyPI packages with 56,000+ downloads that install surveillance malware.
Security News
The ongoing npm phishing campaign escalates as attackers hijack the popular 'is' package, embedding malware in multiple versions.